home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / jockey / backend.py next >
Text File  |  2009-07-14  |  27KB  |  734 lines
  1. # -*- coding: UTF-8 -*-
  2.  
  3. # (c) 2008 Canonical Ltd.
  4. #
  5. # This program is free software; you can redistribute it and/or modify
  6. # it under the terms of the GNU General Public License as published by
  7. # the Free Software Foundation; either version 2 of the License, or
  8. # (at your option) any later version.
  9. #
  10. # This program is distributed in the hope that it will be useful,
  11. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. # GNU General Public License for more details.
  14. #
  15. # You should have received a copy of the GNU General Public License along
  16. # with this program; if not, write to the Free Software Foundation, Inc.,
  17. # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18.  
  19. '''Backend manager.
  20.  
  21. This encapsulates all services of the backend and manages all handlers.
  22. '''
  23.  
  24. import logging, os, os.path, signal, threading, sys
  25.  
  26. import gobject
  27. import dbus
  28. import dbus.service
  29. import dbus.mainloop.glib
  30.  
  31. from oslib import OSLib
  32. import detection, xorg_driver
  33.  
  34. DBUS_BUS_NAME = 'com.ubuntu.DeviceDriver'
  35.  
  36. #--------------------------------------------------------------------#
  37.  
  38. class UnknownHandlerException(dbus.DBusException):
  39.     _dbus_error_name = 'com.ubuntu.DeviceDriver.UnknownHandlerException'
  40.  
  41. class InvalidModeException(dbus.DBusException):
  42.     _dbus_error_name = 'com.ubuntu.DeviceDriver.InvalidModeException'
  43.  
  44. class InvalidDriverDBException(dbus.DBusException):
  45.     _dbus_error_name = 'com.ubuntu.DeviceDriver.InvalidDriverDBException'
  46.  
  47. class PermissionDeniedByPolicy(dbus.DBusException):
  48.     _dbus_error_name = 'com.ubuntu.DeviceDriver.PermissionDeniedByPolicy'
  49.  
  50. class BackendCrashError(SystemError):
  51.     pass
  52.  
  53. #--------------------------------------------------------------------#
  54.  
  55. def dbus_sync_call_signal_wrapper(dbus_iface, fn, handler_map, *args, **kwargs):
  56.     '''Run a D-BUS method call while receiving signals.
  57.  
  58.     This function is an Ugly HackΓäó, since a normal synchronous dbus_iface.fn()
  59.     call does not cause signals to be received until the method returns. Thus
  60.     it calls fn asynchronously and sets up a temporary main loop to receive
  61.     signals and call their handlers; these are assigned in handler_map (signal
  62.     name ΓåÆ signal handler).
  63.     '''
  64.     if not hasattr(dbus_iface, 'connect_to_signal'):
  65.         # not a D-BUS object
  66.         return getattr(dbus_iface, fn)(*args, **kwargs)
  67.  
  68.     def _h_reply(result):
  69.         global _h_reply_result
  70.         _h_reply_result = result
  71.         loop.quit()
  72.  
  73.     def _h_error(exception):
  74.         global _h_exception_exc
  75.         _h_exception_exc = exception
  76.         loop.quit()
  77.  
  78.     loop = gobject.MainLoop()
  79.     global _h_reply_result, _h_exception_exc
  80.     _h_reply_result = None
  81.     _h_exception_exc = None
  82.     kwargs['reply_handler'] = _h_reply
  83.     kwargs['error_handler'] = _h_error
  84.     kwargs['timeout'] = 86400
  85.     for signame, sighandler in handler_map.iteritems():
  86.         dbus_iface.connect_to_signal(signame, sighandler)
  87.     dbus_iface.get_dbus_method(fn)(*args, **kwargs)
  88.     loop.run()
  89.     if _h_exception_exc:
  90.         raise _h_exception_exc
  91.     return _h_reply_result
  92.  
  93. #--------------------------------------------------------------------#
  94.  
  95. def convert_dbus_exceptions(fn, *args, **kwargs):
  96.     '''Convert D-Bus exceptions to their actual exception types'''
  97.     try:
  98.         return fn(*args, **kwargs)
  99.     except dbus.DBusException, e:
  100.         if e._dbus_error_name == PermissionDeniedByPolicy._dbus_error_name:
  101.             raise PermissionDeniedByPolicy(str(e))
  102.         elif e._dbus_error_name == InvalidModeException._dbus_error_name:
  103.             raise InvalidModeException(str(e))
  104.         elif e._dbus_error_name == UnknownHandlerException._dbus_error_name:
  105.             raise UnknownHandlerException(str(e))
  106.         elif e._dbus_error_name == 'org.freedesktop.DBus.Python.SystemError':
  107.             raise SystemError(str(e))
  108.         elif e._dbus_error_name == 'org.freedesktop.DBus.Error.NoReply':
  109.             raise BackendCrashError
  110.         else:
  111.             raise
  112.  
  113. #--------------------------------------------------------------------#
  114.  
  115. class Backend(dbus.service.Object):
  116.     '''Backend manager.
  117.  
  118.     This encapsulates all services of the backend and manages all handlers. It
  119.     is implemented as a dbus.service.Object, so that it can be called through
  120.     D-BUS as well (on the /DeviceDriver object path).
  121.     '''
  122.     DBUS_INTERFACE_NAME = 'com.ubuntu.DeviceDriver'
  123.  
  124.     def __init__(self, handler_dir=None, detect=True):
  125.         '''Initialize backend (no hardware/driver detection).
  126.  
  127.         In order to be fast and not block client side applications for very
  128.         long, detect can be set to False; in that case this constructor does
  129.         not detect hardware and drivers, and client-side applications must call
  130.         detect() at program start.
  131.         '''
  132.         self.handler_dir = handler_dir
  133.         self.handler_pool = {}
  134.         self.hardware = None
  135.  
  136.         # cached D-BUS interfaces for _check_polkit_privilege()
  137.         self.dbus_info = None
  138.         self.polkit = None
  139.  
  140.         self.enforce_polkit = True
  141.         self._package_operation_in_progress = False
  142.  
  143.         if detect:
  144.             self.detect()
  145.  
  146.     #
  147.     # Client API (through D-BUS)
  148.     #
  149.  
  150.     @dbus.service.method(DBUS_INTERFACE_NAME,
  151.         in_signature='', out_signature='', sender_keyword='sender',
  152.         connection_keyword='conn')
  153.     def detect(self, sender=None, conn=None):
  154.         '''Detect available hardware and handlers.
  155.  
  156.         This method can take pretty long, so it should be called asynchronously
  157.         with a large (or indefinite) timeout, and client UIs should display a
  158.         bouncing progress bar (if appropriate). If the backend is already
  159.         initialized, this returns immediately.
  160.  
  161.         This must be called once at client-side program start.
  162.         '''
  163.         self._reset_timeout()
  164.         self._check_polkit_privilege(sender, conn, 'com.ubuntu.devicedriver.info')
  165.  
  166.         if not self.hardware:
  167.             self.hardware = detection.get_hardware()
  168.             self.driver_dbs = [detection.LocalKernelModulesDriverDB(),
  169.                 detection.OpenPrintingDriverDB()]
  170.             self._detect_handlers()
  171.  
  172.     @dbus.service.method(DBUS_INTERFACE_NAME,
  173.         in_signature='s', out_signature='as', sender_keyword='sender',
  174.         connection_keyword='conn')
  175.     def available(self, mode='any', sender=None, conn=None):
  176.         '''List available driver IDs.
  177.         
  178.         Mode can be "any" (default) to return all available drivers, or
  179.         "free"/"nonfree" to select by license.
  180.         '''
  181.         self._reset_timeout()
  182.         self._check_polkit_privilege(sender, conn, 'com.ubuntu.devicedriver.info')
  183.  
  184.         if mode == 'any':
  185.             return self.handlers.keys()
  186.  
  187.         if mode not in ('free', 'nonfree'):
  188.             raise InvalidModeException(
  189.                 'invalid mode %s: must be "free", "nonfree", or "any"' % mode)
  190.  
  191.         recommended = []
  192.         nonrecommended = []
  193.         for (h_id, h) in self.handlers.iteritems():
  194.             if h.free() == (mode == 'free'):
  195.                 if h.recommended():
  196.                     recommended.append(h_id)
  197.                 else:
  198.                     nonrecommended.append(h_id)
  199.         return recommended + nonrecommended
  200.  
  201.     @dbus.service.method(DBUS_INTERFACE_NAME,
  202.         in_signature='', out_signature='as', sender_keyword='sender',
  203.         connection_keyword='conn')
  204.     def get_hardware(self, sender=None, conn=None):
  205.         '''List available hardware IDs.'''
  206.  
  207.         self._reset_timeout()
  208.         self._check_polkit_privilege(sender, conn, 'com.ubuntu.devicedriver.info')
  209.         return [hwid.type + ':' + hwid.id for hwid in self.hardware]
  210.  
  211.     @dbus.service.method(DBUS_INTERFACE_NAME,
  212.         in_signature='s', out_signature='a{ss}', sender_keyword='sender',
  213.         connection_keyword='conn')
  214.     def handler_info(self, handler_id, sender=None, conn=None):
  215.         '''Return details about a particular handler.
  216.  
  217.         The information is returned in a property_name ΓåÆ property_value
  218.         dictionary. Boolean values are encoded as 'True' and 'False' strings.
  219.         If a particular attribute is not set, it will not appear in the
  220.         dictionary.
  221.         '''
  222.         self._reset_timeout()
  223.         self._check_polkit_privilege(sender, conn, 'com.ubuntu.devicedriver.info')
  224.  
  225.         try:
  226.             h = self.handlers[handler_id]
  227.         except KeyError:
  228.             raise UnknownHandlerException('Unknown handler: %s' % handler_id)
  229.  
  230.         info = {
  231.             'id': h.id(),
  232.             'name': h.name(),
  233.             'free': str(h.free()),
  234.             'enabled': str(h.enabled()),
  235.             'used': str(h.used()),
  236.             'changed': str(h.changed()),
  237.             'recommended': str(h.recommended()),
  238.             'announce': str(h.announce),
  239.         }
  240.         for f in ['description', 'rationale', 'can_change']:
  241.             v = getattr(h, f)()
  242.             if v:
  243.                 info[f] = v
  244.         for f in ['package', 'repository', 'driver_vendor', 'version',
  245.             'license']:
  246.             v = getattr(h, f)
  247.             if v:
  248.                 info[f] = v
  249.  
  250.         return info
  251.  
  252.     @dbus.service.method(DBUS_INTERFACE_NAME,
  253.         in_signature='s', out_signature='as', sender_keyword='sender',
  254.         connection_keyword='conn')
  255.     def handler_files(self, handler_id, sender=None, conn=None):
  256.         '''Return list of files installed by a handler.'''
  257.  
  258.         try:
  259.             h = self.handlers[handler_id]
  260.         except KeyError:
  261.             raise UnknownHandlerException('Unknown handler: %s' % handler_id)
  262.  
  263.         if not h.package or not h.enabled():
  264.             return []
  265.  
  266.         try:
  267.             return OSLib.inst.package_files(h.package)
  268.         except ValueError:
  269.             return []
  270.  
  271.     @dbus.service.method(DBUS_INTERFACE_NAME,
  272.         in_signature='sb', out_signature='b', sender_keyword='sender',
  273.         connection_keyword='conn')
  274.     def set_enabled(self, handler_id, enable, sender=None, conn=None):
  275.         '''Enable or disable a driver.
  276.  
  277.         This enables (enable=True) or disables (enable=False) the given Driver
  278.         ID. Return True if the handler could be activated immediately, or False
  279.         if the system needs a reboot for the changes to become effective.
  280.         '''
  281.         self._reset_timeout()
  282.         self._check_polkit_privilege(sender, conn, 'com.ubuntu.devicedriver.install')
  283.  
  284.         try:
  285.             h = self.handlers[handler_id]
  286.         except KeyError:
  287.             raise UnknownHandlerException('Unknown handler: %s' % handler_id)
  288.  
  289.         if enable:
  290.             f = h.enable
  291.         else:
  292.             f = h.disable
  293.  
  294.         if not conn:
  295.             # not called through D-BUS, thus don't send progress signals
  296.             return f()
  297.  
  298.         if h.package:
  299.             # start progress information early; for package operations we will
  300.             # always have a progress bar, avoid delays from the package manager
  301.             # with progress reporting
  302.             if enable:
  303.                 self.install_progress('download', -1, -1)
  304.             else:
  305.                 self.remove_progress(-1, -1)
  306.  
  307.         def _f_result_wrapper():
  308.             try:
  309.                 self._f_result = f()
  310.             except:
  311.                 self._f_exception = sys.exc_info()
  312.  
  313.         # Call enable/disable in a separate thread, in case it does long
  314.         # actions and thus we need to signal progress
  315.         self._f_exception = None
  316.         t_f = threading.Thread(None, _f_result_wrapper,
  317.             'thread_enable_disable', [], {})
  318.         t_f.start()
  319.         while True:
  320.             t_f.join(0.2)
  321.             if not t_f.isAlive():
  322.                 break
  323.             # {install,remove}_package() already report percentage process,
  324.             # don't interfere with that
  325.             if not self._package_operation_in_progress:
  326.                 if enable:
  327.                     self.install_progress('install', -1, -1)
  328.                 else:
  329.                     self.remove_progress(-1, -1)
  330.         if self._f_exception:
  331.             raise self._f_exception[0], self._f_exception[1], self._f_exception[2]
  332.         return self._f_result
  333.  
  334.     @dbus.service.method(DBUS_INTERFACE_NAME,
  335.         in_signature='s', out_signature='(asas)', sender_keyword='sender',
  336.         connection_keyword='conn')
  337.     def new_used_available(self, mode='any', sender=None, conn=None):
  338.         '''Check for newly used or available drivers since last call.
  339.         
  340.         Return (new_used, new_avail) with lists of new drivers which are in
  341.         use, and new drivers which got available but are disabled.
  342.         Mode can be "any" (default) to return all available drivers, or
  343.         "free"/"nonfree" to select by license.
  344.         '''
  345.         self._reset_timeout()
  346.         self._check_polkit_privilege(sender, conn, 'com.ubuntu.devicedriver.check')
  347.  
  348.         if mode not in ('any', 'free', 'nonfree'):
  349.             raise InvalidModeException(
  350.                 'invalid mode %s: must be "free", "nonfree", or "any"' % mode)
  351.  
  352.         # read previously seen/used handlers
  353.         seen = set()
  354.         used = set()
  355.  
  356.         if os.path.exists(OSLib.inst.check_cache):
  357.             f = open(OSLib.inst.check_cache)
  358.             for line in f:
  359.                 try:
  360.                     (flag, h) = line.split(None, 1)
  361.                     h = unicode(h, 'UTF-8')
  362.                 except ValueError:
  363.                     logging.error('invalid line in %s: %s',
  364.                         OSLib.inst.check_cache, line)
  365.                 if flag == 'seen':
  366.                     seen.add(h.strip())
  367.                 elif flag == 'used':
  368.                     used.add(h.strip())
  369.                 else:
  370.                     logging.error('invalid flag in %s: %s',
  371.                         OSLib.inst.check_cache, line)
  372.             f.close()
  373.  
  374.         # check for newly used/available handlers
  375.         new_avail = []
  376.         new_used = []
  377.         for h_id, h in self.handlers.iteritems():
  378.             if (mode == 'free' and not h.free()) or \
  379.                (mode == 'nonfree' and h.free()):
  380.                continue
  381.             if h_id not in seen:
  382.                 new_avail.append(h_id)
  383.                 logging.debug('handler %s previously unseen', h_id)
  384.             if h_id not in used and h.used():
  385.                 new_used.append(h_id)
  386.                 logging.debug('handler %s previously unused', h_id)
  387.  
  388.         # write back cache
  389.         logging.debug('writing back check cache %s', 
  390.             OSLib.inst.check_cache)
  391.         seen.update(new_avail)
  392.         used.update(new_used)
  393.         f = open(OSLib.inst.check_cache, 'w')
  394.         for s in seen:
  395.             print >> f, 'seen', s
  396.         for u in used:
  397.             print >> f, 'used', u
  398.         f.close()
  399.  
  400.         # throw out newly available handlers which are already enabled, no need
  401.         # to bother people about them
  402.         for h_id in new_avail + []: # create a copy for iteration
  403.             try:
  404.                 if self.handlers[h_id].enabled():
  405.                     logging.debug('%s is already enabled or not available, not announcing', h_id)
  406.                     new_avail.remove(h_id)
  407.             except ValueError:
  408.                 # thrown if package does not exist; might be a race condition
  409.                 # between jockey --check and a cron job fetching new package
  410.                 # indexes at session start, see LP #200089
  411.                 continue
  412.  
  413.         return (new_used, new_avail)
  414.  
  415.     @dbus.service.method(DBUS_INTERFACE_NAME,
  416.         in_signature='', out_signature='s', sender_keyword='sender',
  417.         connection_keyword='conn')
  418.     def check_composite(self, sender=None, conn=None):
  419.         '''Check for a composite-enabling X.org driver.
  420.  
  421.         If one is available and not enabled, return its ID, otherwise return
  422.         an empty string.
  423.         '''
  424.         self._reset_timeout()
  425.         self._check_polkit_privilege(sender, conn, 'com.ubuntu.devicedriver.info')
  426.  
  427.         for h_id, h in self.handlers.iteritems():
  428.             if isinstance(h, xorg_driver.XorgDriverHandler) and \
  429.                 h.enables_composite():
  430.                 if h.enabled():
  431.                     logging.debug('Driver "%s" is already enabled and supports the composite extension.' % h.name())
  432.                     return ''
  433.                 else:
  434.                     return h_id
  435.         return ''
  436.  
  437.     @dbus.service.method(DBUS_INTERFACE_NAME,
  438.         in_signature='sas', out_signature='', sender_keyword='sender',
  439.         connection_keyword='conn')
  440.     def add_driverdb(self, db_class, db_args, sender=None, conn=None):
  441.         '''Add driver DB.
  442.  
  443.         db_class is a DriverDB class name; db_args are its constructor
  444.         arguments. If there is an error instantiating the driver DB, an
  445.         InvalidDriverDBException is thrown.
  446.         '''
  447.         try:
  448.             cls = getattr(detection, db_class)
  449.         except AttributeError, e:
  450.             raise InvalidDriverDBException(str(e))
  451.  
  452.         try:
  453.             inst = cls(*db_args)
  454.         except Exception, e:
  455.             raise InvalidDriverDBException(str(e))
  456.  
  457.         logging.debug('add_driverdb: Adding %s', str(inst))
  458.  
  459.         self.driver_dbs.append(inst)
  460.  
  461.         # do not call _detect_handlers(), it re-detects everything
  462.         for h in detection.get_db_handlers(self, inst, self.hardware):
  463.             self.handlers[h.id()] = h
  464.  
  465.     @dbus.service.method(DBUS_INTERFACE_NAME,
  466.         in_signature='', out_signature='', sender_keyword='sender',
  467.         connection_keyword='conn')
  468.     def update_driverdb(self, sender=None, conn=None):
  469.         '''Query driver DBs for updates.'''
  470.  
  471.         self._reset_timeout()
  472.         self._check_polkit_privilege(sender, conn, 'com.ubuntu.devicedriver.update')
  473.  
  474.         for db in self.driver_dbs:
  475.             logging.debug('update_driverdb: updating %s', db.__class__)
  476.             db.update(self.hardware)
  477.  
  478.         self._detect_handlers()
  479.  
  480.     @dbus.service.method(DBUS_INTERFACE_NAME,
  481.         in_signature='s', out_signature='as', sender_keyword='sender',
  482.         connection_keyword='conn')
  483.     def search_driver(self, hwid, sender=None, conn=None):
  484.         '''Search drivers matching a HardwareID.
  485.  
  486.         This also finds drivers for hardware which is not present locally and
  487.         thus checks all the driver DBs again.
  488.  
  489.         Mode can be "any" (default) to return all available drivers, or
  490.         "free"/"nonfree" to select by license.
  491.         '''
  492.         # TODO: support freeness mode
  493.         self._reset_timeout()
  494.         self._check_polkit_privilege(sender, conn, 'com.ubuntu.devicedriver.info')
  495.  
  496.         (t, i) = hwid.split(':', 1)
  497.         hardware_id = detection.HardwareID(t, i)
  498.  
  499.         recommended = []
  500.         nonrecommended = []
  501.         for db in self.driver_dbs:
  502.             db.update([hardware_id])
  503.         handlers = detection.get_handlers(self, self.driver_dbs,
  504.             hardware=[hardware_id], hardware_only=True)
  505.         for h in handlers:
  506.             id = h.id()
  507.             if id not in self.handlers:
  508.                 self.handlers[id] = h
  509.             if h.recommended():
  510.                 recommended.append(id)
  511.             else:
  512.                 nonrecommended.append(id)
  513.  
  514.         return recommended + nonrecommended
  515.  
  516.     @dbus.service.signal(DBUS_INTERFACE_NAME)
  517.     def install_progress(self, phase, curr, total):
  518.         '''Report package installation progress.
  519.  
  520.         'phase' is 'download' or 'install'. current and/or total might be -1 if
  521.         time cannot be determined.
  522.         '''
  523.         return False # TODO: cancel not implemented
  524.  
  525.     @dbus.service.signal(DBUS_INTERFACE_NAME)
  526.     def remove_progress(self, curr, total):
  527.         '''Report package removal progress.
  528.  
  529.         current and/or total might be -1 if time cannot be determined.
  530.         '''
  531.         return False
  532.  
  533.     #
  534.     # Internal API for calling from Handlers (not exported through D-BUS)
  535.     #
  536.  
  537.     def install_package(self, package):
  538.         '''Install software package.'''
  539.  
  540.         if OSLib.inst.package_installed(package):
  541.             return
  542.  
  543.         # only pass D-BUS signal callback if we are called as a D-BUS backend
  544.         self._package_operation_in_progress = True
  545.         OSLib.inst.install_package(package, 
  546.             hasattr(self, '_locations') and self.install_progress or None)
  547.         if OSLib.inst.package_installed(package):
  548.             self._update_installed_packages([package], [])
  549.         self._package_operation_in_progress = False
  550.  
  551.     def remove_package(self, package):
  552.         '''Remove software package.'''
  553.  
  554.         if not OSLib.inst.package_installed(package):
  555.             return
  556.  
  557.         # only pass D-BUS signal callback if we are called as a D-BUS backend
  558.         self._package_operation_in_progress = True
  559.         OSLib.inst.remove_package(package,
  560.             hasattr(self, '_locations') and self.remove_progress or None)
  561.         if not OSLib.inst.package_installed(package):
  562.             self._update_installed_packages([], [package])
  563.         self._package_operation_in_progress = False
  564.  
  565.     #
  566.     # D-BUS control API
  567.     #
  568.  
  569.     def run_dbus_service(self, timeout=None, send_usr1=False):
  570.         '''Run D-BUS server.
  571.  
  572.         If no timeout is given, the server will run forever, otherwise it will
  573.         return after the specified number of seconds.
  574.  
  575.         If send_usr1 is True, this will send a SIGUSR1 to the parent process
  576.         once the server is ready to take requests.
  577.         '''
  578.         dbus.service.Object.__init__(self, self.bus, '/DeviceDriver')
  579.         main_loop = gobject.MainLoop()
  580.         self._timeout = False
  581.         if timeout:
  582.             def _t():
  583.                 main_loop.quit()
  584.                 return True
  585.             gobject.timeout_add(timeout * 1000, _t)
  586.  
  587.         # send parent process a signal that we are ready now
  588.         if send_usr1:
  589.             os.kill(os.getppid(), signal.SIGUSR1)
  590.  
  591.         # run until we time out
  592.         while not self._timeout:
  593.             if timeout:
  594.                 self._timeout = True
  595.             main_loop.run()
  596.  
  597.     @classmethod
  598.     def create_dbus_server(klass, session_bus=False, handler_dir=None):
  599.         '''Return a D-BUS server backend instance.
  600.  
  601.         Normally this connects to the system bus. Set session_bus to True to
  602.         connect to the session bus (for testing). 
  603.         
  604.         The created backend does not yet have hardware and drivers detected,
  605.         thus clients need to call detect().
  606.         '''
  607.         import dbus.mainloop.glib
  608.  
  609.         backend = Backend(handler_dir, detect=False)
  610.         dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
  611.         if session_bus:
  612.             backend.bus = dbus.SessionBus()
  613.             backend.enforce_polkit = False
  614.         else:
  615.             backend.bus = dbus.SystemBus()
  616.         backend.dbus_name = dbus.service.BusName(DBUS_BUS_NAME, backend.bus)
  617.         return backend
  618.  
  619.     @classmethod
  620.     def create_dbus_client(klass, session_bus=False):
  621.         '''Return a client-side D-BUS interface for Backend.
  622.  
  623.         Normally this connects to the system bus. Set session_bus to True to
  624.         connect to the session bus (for testing).
  625.         '''
  626.         dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
  627.         if session_bus:
  628.             bus = dbus.SessionBus()
  629.         else:
  630.             bus = dbus.SystemBus()
  631.         obj = bus.get_object(DBUS_BUS_NAME, '/DeviceDriver')
  632.         return dbus.Interface(obj, Backend.DBUS_INTERFACE_NAME)
  633.  
  634.     #
  635.     # Internal methods
  636.     #
  637.  
  638.     def _update_installed_packages(self, add, remove):
  639.         '''Update backup_dir/installed_packages list of driver packages.
  640.         
  641.         This keeps a log of all packages that jockey installed for supporting
  642.         drivers, so that distribution installers on live CDs can push them into
  643.         the installed system as well.
  644.  
  645.         add and remove are lists which package names to add/remove from it.
  646.         '''
  647.         # get current list
  648.         current = set()
  649.         path = os.path.join(OSLib.inst.backup_dir, 'installed_packages')
  650.         if os.path.exists(path):
  651.             for line in open(path):
  652.                 line = line.strip()
  653.                 if line:
  654.                     current.add(line)
  655.     
  656.         current = current.union(add).difference(remove)
  657.         
  658.         if current:
  659.             # write it back
  660.             f = open(path, 'w')
  661.             for p in current:
  662.                 print >> f, p
  663.             f.close()
  664.         else:
  665.             # delete it if it is empty
  666.             if os.path.exists(path):
  667.                 os.unlink(path)
  668.  
  669.     def _detect_handlers(self):
  670.         '''Detect available handlers and their state.
  671.         
  672.         This initializes self.handlers as id ΓåÆ Handler map.'''
  673.  
  674.         self.handlers = {}
  675.         for h in detection.get_handlers(self,
  676.                 self.driver_dbs,
  677.                 handler_dir=self.handler_dir,
  678.                 hardware=self.hardware):
  679.             self.handlers[h.id()] = h
  680.  
  681.     def _reset_timeout(self):
  682.         '''Reset the D-BUS server timeout.'''
  683.  
  684.         self._timeout = False
  685.  
  686.     def _check_polkit_privilege(self, sender, conn, privilege):
  687.         '''Verify that sender has a given PolicyKit privilege.
  688.  
  689.         sender is the sender's (private) D-BUS name, such as ":1:42"
  690.         (sender_keyword in @dbus.service.methods). conn is
  691.         the dbus.Connection object (connection_keyword in
  692.         @dbus.service.methods). privilege is the PolicyKit privilege string.
  693.  
  694.         This method returns if the caller is privileged, and otherwise throws a
  695.         PermissionDeniedByPolicy exception.
  696.         '''
  697.         if sender is None and conn is None:
  698.             # called locally, not through D-BUS
  699.             return
  700.         if not self.enforce_polkit:
  701.             # that happens for testing purposes when running on the session
  702.             # bus, and it does not make sense to restrict operations here
  703.             return
  704.  
  705.         # get peer PID
  706.         if self.dbus_info is None:
  707.             self.dbus_info = dbus.Interface(conn.get_object('org.freedesktop.DBus',
  708.                 '/org/freedesktop/DBus/Bus', False), 'org.freedesktop.DBus')
  709.         pid = self.dbus_info.GetConnectionUnixProcessID(sender)
  710.         
  711.         # query PolicyKit
  712.         if self.polkit is None:
  713.             self.polkit = dbus.Interface(dbus.SystemBus().get_object(
  714.                 'org.freedesktop.PolicyKit1',
  715.                 '/org/freedesktop/PolicyKit1/Authority', False),
  716.                 'org.freedesktop.PolicyKit1.Authority')
  717.         try:
  718.             # we don't need is_challenge return here, since we call with AllowUserInteraction
  719.             (is_auth, _, details) = self.polkit.CheckAuthorization(
  720.                     ('unix-process', {'pid': dbus.UInt32(pid, variant_level=1)}), 
  721.                     privilege, {'': ''}, dbus.UInt32(1), '', timeout=600)
  722.         except dbus.DBusException, e:
  723.             if e._dbus_error_name == 'org.freedesktop.DBus.Error.ServiceUnknown':
  724.                 # polkitd timed out, connect again
  725.                 self.polkit = None
  726.                 return self._check_polkit_privilege(sender, conn, privilege)
  727.             else:
  728.                 raise
  729.  
  730.         if not is_auth:
  731.             logging.debug('_check_polkit_privilege: sender %s on connection %s pid %i is not authorized for %s: %s' %
  732.                     (sender, conn, pid, privilege, str(details)))
  733.             raise PermissionDeniedByPolicy(privilege)
  734.